package com.atguigu.ssyx.product.service.impl;
import java.math.BigDecimal;

import com.atguigu.ssyx.common.constant.MqConst;
import com.atguigu.ssyx.common.service.RabbitService;
import com.google.common.collect.Lists;

import java.util.ArrayList;
import java.util.Date;
import com.google.common.collect.Maps;

import com.atguigu.ssyx.model.product.SkuAttrValue;
import com.atguigu.ssyx.model.product.SkuImage;
import com.atguigu.ssyx.model.product.SkuInfo;
import com.atguigu.ssyx.model.product.SkuPoster;
import com.atguigu.ssyx.product.mapper.SkuInfoMapper;
import com.atguigu.ssyx.product.service.SkuAttrValueService;
import com.atguigu.ssyx.product.service.SkuImageService;
import com.atguigu.ssyx.product.service.SkuInfoService;
import com.atguigu.ssyx.product.service.SkuPosterService;
import com.atguigu.ssyx.vo.product.SkuInfoQueryVo;
import com.atguigu.ssyx.vo.product.SkuInfoVo;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.util.StringUtils;

import java.util.List;

/**
 * @author 杨林
 * @create 2023-07-20 11:44 星期四
 * description:
 */
@Service
@Slf4j
public class SkuInfoServiceImpl extends ServiceImpl<SkuInfoMapper, SkuInfo> implements SkuInfoService {
    
    @Autowired
    private SkuInfoMapper skuInfoMapper;
    
    @Autowired
    SkuPosterService skuPosterService;
    
    @Autowired
    SkuImageService skuImageService;
    
    @Autowired
    SkuAttrValueService skuAttrValueService;
    
    @Autowired
    private RabbitService rabbitService;

    /**
     * 获取Sku分页列表
     * @param page
     * @param limit
     * @param skuInfoQueryVo
     * @return
     */
    @Override
    public IPage<SkuInfo> getPageList(Long page, Long limit, SkuInfoQueryVo skuInfoQueryVo) {
        //构建分页条件
        Page<SkuInfo> skuInfoPage = new Page<>(page, limit);
        
        //构建查询条件
        LambdaQueryWrapper<SkuInfo> wrapper = new LambdaQueryWrapper<>();
        if (skuInfoQueryVo.getCategoryId() != null){
            wrapper.eq(SkuInfo::getCategoryId,skuInfoQueryVo.getCategoryId());
        }
        if (skuInfoQueryVo.getSkuType() != null){
            wrapper.eq(SkuInfo::getSkuType,skuInfoQueryVo.getSkuType());
        }
        if (skuInfoQueryVo.getKeyword() != null){
            wrapper.like(SkuInfo::getSkuName,skuInfoQueryVo.getKeyword());
        }
        Page<SkuInfo> pageModel = skuInfoMapper.selectPage(skuInfoPage, wrapper);
        return pageModel;
    }


    /**
     * 商品上架：根据商品id修改商品发布状态
     * @param id
     * @param status
     */
    @Override
    public void publish(Long id, Integer status) {
        //更改发布状态
        if (status == 1){
            SkuInfo skuInfoUp = new SkuInfo();
            skuInfoUp.setId(id);
            skuInfoUp.setPublishStatus(1);
            skuInfoMapper.updateById(skuInfoUp);
            
            //商品上架：发送mq消息，同步es
            rabbitService.sendMessage(MqConst.EXCHANGE_GOODS_DIRECT,MqConst.ROUTING_GOODS_UPPER,id);
        }else {
            SkuInfo skuInfoUp = new SkuInfo();
            skuInfoUp.setId(id);
            skuInfoUp.setPublishStatus(0);
            skuInfoMapper.updateById(skuInfoUp);
            
            //商品下架：发送mq消息，同步es
            rabbitService.sendMessage(MqConst.EXCHANGE_GOODS_DIRECT,MqConst.ROUTING_GOODS_LOWER,id);
        }
    }

    /**
     * 商品审核：根据商品id修改商品审核状态
     * @param id
     * @param status
     */
    @Override
    public void check(Long id, Integer status) {
        skuInfoMapper.check(id,status);
    }

    /**
     * 新人专享
     * @param id
     * @param status
     */
    @Override
    @Transactional
    public void isNewPerson(Long id, Integer status) {
        skuInfoMapper.isNewPerson(id,status);
    }

    /**
     * 新增商品SKU信息
     * @param skuInfoVo
     */
    @Transactional(rollbackFor = {Exception.class})  //开启事务，代码中出现异常时回滚
    @Override
    public void saveSkuInfo(SkuInfoVo skuInfoVo) {
        SkuInfo skuInfo = new SkuInfo();
        
        //保存SKU基本信息
        BeanUtils.copyProperties(skuInfoVo,skuInfo);
        this.save(skuInfo);
        
        //获取商品SKU的id
        Long id = skuInfo.getId();

        //保存SKU海报
        List<SkuPoster> skuPosterList = skuInfoVo.getSkuPosterList();
        //为海报设置skuId
        skuPosterList.forEach(item -> item.setSkuId(id));
        skuPosterService.saveBatch(skuPosterList);
        
        //保存SKU图片
        List<SkuImage> skuImagesList = skuInfoVo.getSkuImagesList();
        //为图片设置skuId
        skuImagesList.forEach(item ->  {
            int sort = 1;
            item.setSkuId(id);
            item.setSort(sort);
            sort += 1;
        });
        skuImageService.saveBatch(skuImagesList);
      
        
        //保存SKU平台属性
        List<SkuAttrValue> skuAttrValueList = skuInfoVo.getSkuAttrValueList();
        //为平台属性设置skuId
        skuAttrValueList.forEach(item -> {
            int sort = 1;
            item.setSkuId(id);
            item.setSort(sort);
            sort += 1;
        });
        skuAttrValueService.saveBatch(skuAttrValueList);
        log.info("商品sku信息保存完毕");
    }


    /**
     * 根据商品id获取Sku所有信息
     * @param id
     * @return
     */
    @Override
    @Transactional
    public SkuInfoVo getSkuInfoVoById(Long id) {
        SkuInfoVo skuInfoVo = new SkuInfoVo();
        SkuInfo skuInfo = skuInfoMapper.selectById(id);
        //填充商品的基本属性
        skuInfoVo.setCategoryId(skuInfo.getCategoryId());
        skuInfoVo.setAttrGroupId(skuInfo.getAttrGroupId());
        skuInfoVo.setSkuType(skuInfo.getSkuType());
        skuInfoVo.setSkuName(skuInfo.getSkuName());
        skuInfoVo.setImgUrl(skuInfo.getImgUrl());
        skuInfoVo.setPerLimit(skuInfo.getPerLimit());
        skuInfoVo.setPublishStatus(skuInfo.getPublishStatus());
        skuInfoVo.setCheckStatus(skuInfo.getCheckStatus());
        skuInfoVo.setIsNewPerson(skuInfo.getIsNewPerson());
        skuInfoVo.setSort(skuInfo.getSort());
        skuInfoVo.setSkuCode(skuInfo.getSkuCode());
        skuInfoVo.setPrice(skuInfo.getPrice());
        skuInfoVo.setMarketPrice(skuInfo.getMarketPrice());
        skuInfoVo.setStock(skuInfo.getStock());
        skuInfoVo.setLockStock(skuInfo.getLockStock());
        skuInfoVo.setLowStock(skuInfo.getLowStock());
        skuInfoVo.setSale(skuInfo.getSale());
        skuInfoVo.setWareId(skuInfo.getWareId());
        skuInfoVo.setId(skuInfo.getId());
        skuInfoVo.setCreateTime(skuInfo.getCreateTime());
        skuInfoVo.setUpdateTime(skuInfo.getUpdateTime());
        skuInfoVo.setIsDeleted(skuInfo.getIsDeleted());

        //填充商品的图片海报等信息
        skuInfoVo.setSkuPosterList(skuPosterService.getListBySkuId(id));
        skuInfoVo.setSkuAttrValueList(skuAttrValueService.getListBySkuId(id));
        skuInfoVo.setSkuImagesList(skuImageService.getListBySkuId(id));
        return skuInfoVo;
    }


    /**
     * 更新Sku相关信息
     * @param skuInfoVo
     */
    @Transactional   //批量更新是一个事务
    @Override
    public void updateSku(SkuInfoVo skuInfoVo) {
        SkuInfo skuInfo = new SkuInfo();
        //属性填充
        BeanUtils.copyProperties(skuInfoVo,skuInfo);
        //1、更新skuInfo
        skuInfoMapper.updateById(skuInfo);
        
        //2、更新平台属性
        List<SkuAttrValue> skuAttrValueList = skuInfoVo.getSkuAttrValueList();
        //2.1根据skuId批量删除原来的平台属性
        skuAttrValueService.removeSkuAttrValueBySkuId(skuInfo.getId());
        //2.2批量添加新的平台属性信息
        //2.2.1为平台属性设置skuId
        skuAttrValueList.forEach(item -> {
            Integer sort = 1;
            item.setSkuId(skuInfo.getId());
            item.setSort(sort);
            sort += 1;
        });
        skuAttrValueService.saveBatch(skuAttrValueList);
        
        //3、更新图片
        List<SkuImage> skuImagesList = skuInfoVo.getSkuImagesList();
        //3.1根据skuId批量删除原来的图片信息
        skuImageService.removeSkuImageBySkuId(skuInfo.getId());
        //3.2批量添加新的图片信息
        //3.2.1为图片设置skuId
        skuImagesList.forEach(item -> {
            int sort = 1;
            item.setSkuId(skuInfo.getId());
            item.setSort(sort);
            sort += 1;
        });
        skuImageService.saveBatch(skuImagesList);
        
        //4、更新海报
        List<SkuPoster> skuPosterList = skuInfoVo.getSkuPosterList();
        //4.2根据skuId批量删除原来的海报信息
        skuPosterService.removeSkuPosterBySkuId(skuInfo.getId());
        //4.2批量添加新的海报信息
        //4.2.1为海报添加skuId
        skuPosterList.forEach(item -> item.setSkuId(skuInfo.getId()));
        skuPosterService.saveBatch(skuPosterList);
    }


    /**
     * 根据id删除商品信息、平台属性信息、海报信息、图片信息
     * @param id
     */
    @Transactional
    @Override
    public void removeAllById(Long id) {
        //1、删除商品信息
        skuInfoMapper.deleteById(id);
        
        //2、删除商品平台属性信息
        skuAttrValueService.removeSkuAttrValueBySkuId(id);
        
       //3、删除商品海报信息
       skuPosterService.removeSkuPosterBySkuId(id);
       
       //4、删除商品图片信息
        skuImageService.removeSkuImageBySkuId(id);
    }


    /**
     * 根据id批量删除商品信息，商品平台属性信息，商品海报信息，商品图片信息
     * @param ids
     */
    @Transactional
    @Override
    public void removeAllByIds(List<Long> ids) {
        //1、批量删除商品信息
        skuInfoMapper.deleteBatchIds(ids);
        
        //2、批量删除平台属性信息
        skuAttrValueService.removeSkuAttrValueBySkuIds(ids);
        
        //3、批量删除商品海报信息
        skuPosterService.removeSkuPosterBySkuIds(ids);
        
        //4、批量删除商品图片信息
        skuImageService.removeSkuImageByIds(ids);
        
    }

    /**
     * 根据id批量获取sku信息
     * @param skuIdList
     * @return
     */
    @Override
    public List<SkuInfo> findSkuInfoList(List<Long> skuIdList) {
        LambdaQueryWrapper<SkuInfo> wrapper = new LambdaQueryWrapper<>();
        wrapper.in(SkuInfo::getId,skuIdList);
        List<SkuInfo> skuInfos = skuInfoMapper.selectList(wrapper);
        return skuInfos;
    }

    /**
     * 根据关键字获取sku列表
     * @param keyword
     * @return
     */
    @Override
    public List<SkuInfo> findSkuInfoByKeyword(String keyword) {
        LambdaQueryWrapper<SkuInfo> wrapper = new LambdaQueryWrapper<>();
        if (!StringUtils.isEmpty(keyword)){
            wrapper.like(SkuInfo::getSkuName,keyword);
        }
        List<SkuInfo> skuInfos = skuInfoMapper.selectList(wrapper);
        return skuInfos;
    }
}
